home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / share / embryo / include / default.inc
Encoding:
Text File  |  2006-01-09  |  9.3 KB  |  214 lines
  1. /* Float arithmetic
  2.  *
  3.  * (c) Copyright 1999, Artran, Inc.
  4.  * Written by Greg Garner (gmg@artran.com)
  5.  * Modified in March 2001 to include user defined
  6.  * operators for the floating point functions.
  7.  * (c) Copyright 2004, Carsten Haitzler
  8.  * Modified March 2004 by Carsten Haitzler <raster@rasterman.com> to conform
  9.  * to E coding style
  10.  * Became default include for embryo...
  11.  * Added string functions
  12.  * Added rand functions
  13.  * Added time functions
  14.  *
  15.  * This file is provided as is (no warranties).
  16.  */
  17. #if defined DEFAULT_INC
  18. #endinput
  19. #endif
  20. #define DEFAULT_INC
  21.  
  22. #pragma rational Float
  23.  
  24. #define PI  3.1415926535897932384626433832795
  25.  
  26. /* Different methods of rounding */
  27. enum Float_Round_Method
  28. {
  29.    ROUND, FLOOR, CEIL, TOZERO
  30. };
  31. /* different angle addressing modes (default is radians) */
  32. enum Float_Angle_Mode
  33. {
  34.    RADIAN, DEGREES, GRADES
  35. };
  36.  
  37. /* varags - get numebr of args to a function */
  38. native numargs();
  39. /* varags - get arg no "arg" */
  40. native getarg(arg, index=0);
  41. native getsarg(arg, buf[], buflen);
  42. native Float:getfarg(arg, index=0);
  43. /* varags - set arg no "arg" */
  44. native setarg(arg, index=0, value);
  45. native setfarg(arg, index=0, Float:value);
  46.  
  47. /* Convert a string into a floating point value */
  48. native Float:atof(const string[]);
  49. /* Return the fractional part of a float */
  50. native Float:fract(Float:value);
  51. /* Round a float into a integer value */
  52. native       round(Float:value, Float_Round_Method:method=ROUND);
  53. /* Return the square root of value, same as float_power(value, 0.5) */
  54. native Float:sqrt(Float:value);
  55. /* Return the value raised to the power of the exponent */
  56. native Float:pow(Float:value, Float:exponent);
  57. /* Return the logarithm */
  58. native Float:log(Float:value, Float:base=10.0);
  59. /* Return the sine, cosine or tangent. The input angle may be in radian*/
  60. /* degrees or grades. */
  61. native Float:sin(Float:value, Float_Angle_Mode:mode=RADIAN);
  62. native Float:cos(Float:value, Float_Angle_Mode:mode=RADIAN);
  63. native Float:tan(Float:value, Float_Angle_Mode:mode=RADIAN);
  64. /* Return the absolute value */
  65. native Float:abs(Float:value);
  66. /* return integer from string */
  67. native       atoi(str[]);
  68. /* return 0 if string matches glob, non-zero otherwise */
  69. native       fnmatch(glob[], str[]);
  70. /* same as strcmp() */
  71. native       strcmp(str1[], str2[]);
  72. /* same as strncmp */
  73. native       strncmp(str1[], str2[], n);
  74. /* same as strcpy */
  75. native       strcpy(dst[], src[]);
  76. /* same as strncpy  except it nul terminates */
  77. native       strncpy(dst[], src[], n);
  78. /* same as strlen */
  79. native       strlen(str[]);
  80. /* same as strcat */
  81. native       strcat(dst[], src[]);
  82. /* same as strncat except it nul terminates */
  83. native       strncat(dst[], src[], n);
  84. /* prepends src string onto start of dst string */
  85. native       strprep(dst[], src[]);
  86. /* prepends at most n chars from src string onto dst string */
  87. native       strnprep(dst[], src[], n);
  88. /* cuts chars from char n to (not including) n2, and puts them in str */
  89. native       strcut(dst[], str[], n, n2);
  90. /* same as snprintf, except only supports %%, %c, %i, %d, %f, %x, %X, %s, \n and \t */
  91. native       snprintf(dst[], dstn, fmt[], ...);
  92. /* same as strstr */
  93. native       strstr(str[], ndl[]);
  94. /* same as strchr, except ch must be a 1 charater long string, and returns string index */
  95. native       strchr(str[], ch[]);
  96. /* same as strrchr, except ch must be a 1 charater long string and returns string index */
  97. native       strrchr(str[], ch[]);
  98. /* return random number 0 - 65535 */
  99. native       rand();
  100. /* return random number 0.0 - 1.0 */
  101. native Float:randf();
  102. /* return seconds since midnight as a float */
  103. native Float:seconds();
  104. /* return the current date, year, time etc. in the variables provided */
  105. native       date(&year, &month, &day, &yearday, &weekday, &hr, &min, &Float:sec);
  106.  
  107. /*****************************************************************************/
  108. /*****************************************************************************/
  109. /*****************************************************************************/
  110. /*****************************************************************************/
  111. /*****************************************************************************/
  112. /*****************************************************************************/
  113. /*****************************************************************************/
  114. /*****************************************************************************/
  115. /*****************************************************************************/
  116. /*****************************************************************************/
  117. /*****************************************************************************/
  118. /*****************************************************************************/
  119. /*****************************************************************************/
  120. /*****************************************************************************/
  121. /*****************************************************************************/
  122. /*****************************************************************************/
  123. /*****************************************************************************/
  124. /*****************************************************************************/
  125. /*****************************************************************************/
  126. /*****************************************************************************/
  127. /*****************************************************************************/
  128. /*****************************************************************************/
  129. /*****************************************************************************/
  130. /*****************************************************************************/
  131. /*****************************************************************************/
  132. /*****************************************************************************/
  133.  
  134. /**************************************************/
  135. /* Hidden calls - all are overloaded on operators */
  136. /**************************************************/
  137.  
  138. /* Convert an integer into a floating point value */
  139. native Float:float(value);
  140. /* Multiple two floats together */
  141. native Float:float_mul(Float:oper1, Float:oper2);
  142. /* Divide the dividend float by the divisor float */
  143. native Float:float_div(Float:dividend, Float:divisor);
  144. /* Add two floats together */
  145. native Float:float_add(Float:oper1, Float:oper2);
  146. /* Subtract oper2 float from oper1 float */
  147. native Float:float_sub(Float:oper1, Float:oper2);
  148. /* Compare two integers. If the two elements are equal, return 0. */
  149. /* If the first argument is greater than the second argument, return 1, */
  150. /* If the first argument is less than the second argument, return -1. */
  151. native       float_cmp(Float:oper1, Float:oper2);
  152. /* user defined operators */
  153. native Float:operator*(Float:oper1, Float:oper2) = float_mul;
  154. native Float:operator/(Float:oper1, Float:oper2) = float_div;
  155. native Float:operator+(Float:oper1, Float:oper2) = float_add;
  156. native Float:operator-(Float:oper1, Float:oper2) = float_sub;
  157. native Float:operator=(oper) = float;
  158. stock Float:operator++(Float:oper)
  159.     return oper+1.0;
  160. stock Float:operator--(Float:oper)
  161.     return oper-1.0;
  162. stock Float:operator-(Float:oper)
  163.     return oper^Float:0x80000000; /* IEEE values are sign/magnitude */
  164. stock Float:operator*(Float:oper1, oper2)
  165.     return float_mul(oper1, float(oper2)); /* "*" is commutative */
  166. stock Float:operator/(Float:oper1, oper2)
  167.     return float_div(oper1, float(oper2));
  168. stock Float:operator/(oper1, Float:oper2)
  169.     return float_div(float(oper1), oper2);
  170. stock Float:operator+(Float:oper1, oper2)
  171.     return float_add(oper1, float(oper2)); /* "+" is commutative */
  172. stock Float:operator-(Float:oper1, oper2)
  173.     return float_sub(oper1, float(oper2));
  174. stock Float:operator-(oper1, Float:oper2)
  175.     return float_sub(float(oper1), oper2);
  176. stock bool:operator==(Float:oper1, Float:oper2)
  177.     return float_cmp(oper1, oper2) == 0;
  178. stock bool:operator==(Float:oper1, oper2)
  179.     return float_cmp(oper1, float(oper2)) == 0;  /* "==" is commutative */
  180. stock bool:operator!=(Float:oper1, Float:oper2)
  181.     return float_cmp(oper1, oper2) != 0;
  182. stock bool:operator!=(Float:oper1, oper2)
  183.     return float_cmp(oper1, float(oper2)) != 0;  /* "!=" is commutative */
  184. stock bool:operator>(Float:oper1, Float:oper2)
  185.     return float_cmp(oper1, oper2) > 0;
  186. stock bool:operator>(Float:oper1, oper2)
  187.     return float_cmp(oper1, float(oper2)) > 0;
  188. stock bool:operator>(oper1, Float:oper2)
  189.     return float_cmp(float(oper1), oper2) > 0;
  190. stock bool:operator>=(Float:oper1, Float:oper2)
  191.     return float_cmp(oper1, oper2) >= 0;
  192. stock bool:operator>=(Float:oper1, oper2)
  193.     return float_cmp(oper1, float(oper2)) >= 0;
  194. stock bool:operator>=(oper1, Float:oper2)
  195.     return float_cmp(float(oper1), oper2) >= 0;
  196. stock bool:operator<(Float:oper1, Float:oper2)
  197.     return float_cmp(oper1, oper2) < 0;
  198. stock bool:operator<(Float:oper1, oper2)
  199.     return float_cmp(oper1, float(oper2)) < 0;
  200. stock bool:operator<(oper1, Float:oper2)
  201.     return float_cmp(float(oper1), oper2) < 0;
  202. stock bool:operator<=(Float:oper1, Float:oper2)
  203.     return float_cmp(oper1, oper2) <= 0;
  204. stock bool:operator<=(Float:oper1, oper2)
  205.     return float_cmp(oper1, float(oper2)) <= 0;
  206. stock bool:operator<=(oper1, Float:oper2)
  207.     return float_cmp(float(oper1), oper2) <= 0;
  208. stock bool:operator!(Float:oper)
  209.     return (_:oper & 0x7fffffff) == 0;
  210. /* forbidden operations */
  211. forward operator%(Float:oper1, Float:oper2);
  212. forward operator%(Float:oper1, oper2);
  213. forward operator%(oper1, Float:oper2);
  214.